revision:
Data types are divided into two groups:
primitive data types - includes byte, short, int, long, float, double, boolean and char;
non-primitive data types - such as string, arrays and classes.
A primitive data type specifies the size and type of variable values, and it has no additional methods. There are eight primitive data types in Java:
Data Type Size Description
byte - 1 byte - stores whole numbers from -128 to 127
short - 2 bytes - stores whole numbers from -32,768 to 32,767
int - 4 bytes - stores whole numbers from -2,147,483,648 to 2,147,483,647
long - 8 bytes - stores whole numbers from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
float - 4 bytes - stores fractional numbers. Sufficient for storing 6 to 7 decimal digits
double - 8 bytes - stores fractional numbers. Sufficient for storing 15 decimal digits
boolean - 1 bit - stores true or false values
char - 2 bytes - stores a single character/letter or ASCII values
primitive number types are divided into two groups:
integer types stores whole numbers, positive or negative (such as 123 or -456), without decimals. Valid types are byte, short, int and long. Which type you should use, depends on the numeric value.
Floating point types represents numbers with a fractional part, containing one or more decimals. There are two types: float and double.
The byte data type can store whole numbers from -128 to 127. This can be used instead of int or other integer types to save memory when you are certain that the value will be within -128 and 127.
example:
public class Main {
public static void main(String[] args) {
byte myNum = 100;
System.out.println(myNum); // 100
}
}
The short data type can store whole numbers from -32768 to 32767:
example:
public class Main {
public static void main(String[] args) {
short myNum = 5000;
System.out.println(myNum); // 5000
}
}
The int data type can store whole numbers from -2147483648 to 2147483647. In general, the int data type is the preferred data type when we create variables with a numeric value.
example:
public class Main {
public static void main(String[] args) {
int myNum = 100000;
System.out.println(myNum); // 100000
}
}
The long data type can store whole numbers from -9223372036854775808 to 9223372036854775807. This is used when int is not large enough to store the value.
Note that you should end the value with an "L".
example:
public class Main {
public static void main(String[] args) {
long myNum = 15000000000L;
System.out.println(myNum); // 15000000000
}
}
The float data type can store fractional numbers from 3.4e−038 to 3.4e+038. Note that you should end the value with an "f".
example:
public class Main {
public static void main(String[] args) {
float myNum = 5.75f;
System.out.println(myNum); //5.75
}
}
The double data type can store fractional numbers from 1.7e−308 to 1.7e+308. Note that you should end the value with a "d".
example:
public class Main {
public static void main(String[] args) {
double myNum = 19.99d;
System.out.println(myNum); //19.99
}
}
!!!! The precision of a floating point value indicates how many digits the value can have after the decimal point. The precision of float is only six or seven decimal digits, while double variables have a precision of about 15 digits. Therefore it is safer to use double for most calculations.
A floating point number can also be a scientific number with an "e" to indicate the power of 10.
example:
public class Main {
public static void main(String[] args) {
float f1 = 35e3f;
double d1 = 12E4d;
System.out.println(f1); //35000.0
System.out.println(d1); // 120000.0
}
}
A Boolean data type is declared with the boolean keyword and can only take the values "true" or "false". Boolean values are mostly used for conditional testing
example:
public class Main {
public static void main(String[] args) {
boolean isJavaFun = true;
boolean isFishTasty = false;
System.out.println(isJavaFun); // true
System.out.println(isFishTasty); // false
}
}
The char data type is used to store a single character. The character must be surrounded by single quotes, like 'A' or 'c'. Alternatively, you can use ASCII values to display certain characters.
example:
public class Main {
public static void main(String[] args) {
char myGrade = 'B';
System.out.println(myGrade); // B
}
}
example:
public class Main {
public static void main(String[] args) {
char myVar1 = 65, myVar2 = 66, myVar3 = 67;
System.out.println(myVar1); // A
System.out.println(myVar2); // B
System.out.println(myVar3); // C
}
}
The String data type is used to store a sequence of characters (text). String values must be surrounded by double quotes.
example:
public class Main {
public static void main(String[] args) {
String greeting = "Hello World";
System.out.println(greeting); // Hello World
}
}
Non-primitive data types are called reference types because they refer to objects.
The main difference between primitive and non-primitive data types are:
Primitive types are predefined (already defined) in Java. Non-primitive types are created by the programmer and is not defined by Java (except for String).
Non-primitive types can be used to call methods to perform certain operations, while primitive types cannot.
A primitive type has always a value, while non-primitive types can be null.
A primitive type starts with a lowercase letter, while non-primitive types starts with an uppercase letter.
The size of a primitive type depends on the data type, while non-primitive types have all the same size.
type casting is when you assign a value of one primitive data type to another type.In Java, there are two types of casting:
widening casting (automatically): converting a smaller type to a larger type size: e.g. byte -> short -> char -> int -> long -> float -> double
narrowing casting (manually): converting a larger type to a smaller size type: e.g. double -> float -> long -> int -> char -> short -> byte
widening casting is done automatically when passing a smaller size type to a larger size type.
example:
public class Main {
public static void main(String[] args) {
int myInt = 9;
double myDouble = myInt; // automatic casting: int to double
System.out.println(myInt); // 9
System.out.println(myDouble); // 9.0
}
}
narrowing casting must be done manually by placing the type in parentheses in front of the value.
example:
public class Main {
public static void main(String[] args) {
double myDouble = 9.78d;
int myInt = (int) myDouble; // explicit casting: double to int
System.out.println(myDouble); // 9.78
System.out.println(myInt); // 9
}
}